package com.zhss.rpc.service;

import static io.grpc.MethodDescriptor.generateFullMethodName;

/**
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.60.2)",
    comments = "Source: NameNodeModelService.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class NameNodeServiceGrpc {

  private NameNodeServiceGrpc() {}

  public static final String SERVICE_NAME = "NameNodeService";

  // Static method descriptors that strictly reflect the proto.
  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RegisterRequest,
      com.zhss.rpc.model.NameNodeModel.RegisterResponse> getRegisterMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "register",
      requestType = com.zhss.rpc.model.NameNodeModel.RegisterRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.RegisterResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RegisterRequest,
      com.zhss.rpc.model.NameNodeModel.RegisterResponse> getRegisterMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RegisterRequest, com.zhss.rpc.model.NameNodeModel.RegisterResponse> getRegisterMethod;
    if ((getRegisterMethod = NameNodeServiceGrpc.getRegisterMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getRegisterMethod = NameNodeServiceGrpc.getRegisterMethod) == null) {
          NameNodeServiceGrpc.getRegisterMethod = getRegisterMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.RegisterRequest, com.zhss.rpc.model.NameNodeModel.RegisterResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "register"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.RegisterRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.RegisterResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("register"))
              .build();
        }
      }
    }
    return getRegisterMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.HeartbeatRequest,
      com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> getHeartbeatMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "heartbeat",
      requestType = com.zhss.rpc.model.NameNodeModel.HeartbeatRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.HeartbeatResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.HeartbeatRequest,
      com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> getHeartbeatMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.HeartbeatRequest, com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> getHeartbeatMethod;
    if ((getHeartbeatMethod = NameNodeServiceGrpc.getHeartbeatMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getHeartbeatMethod = NameNodeServiceGrpc.getHeartbeatMethod) == null) {
          NameNodeServiceGrpc.getHeartbeatMethod = getHeartbeatMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.HeartbeatRequest, com.zhss.rpc.model.NameNodeModel.HeartbeatResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "heartbeat"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.HeartbeatRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.HeartbeatResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("heartbeat"))
              .build();
        }
      }
    }
    return getHeartbeatMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.MkdirRequest,
      com.zhss.rpc.model.NameNodeModel.MkdirResponse> getMkdirMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "mkdir",
      requestType = com.zhss.rpc.model.NameNodeModel.MkdirRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.MkdirResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.MkdirRequest,
      com.zhss.rpc.model.NameNodeModel.MkdirResponse> getMkdirMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.MkdirRequest, com.zhss.rpc.model.NameNodeModel.MkdirResponse> getMkdirMethod;
    if ((getMkdirMethod = NameNodeServiceGrpc.getMkdirMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getMkdirMethod = NameNodeServiceGrpc.getMkdirMethod) == null) {
          NameNodeServiceGrpc.getMkdirMethod = getMkdirMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.MkdirRequest, com.zhss.rpc.model.NameNodeModel.MkdirResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "mkdir"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.MkdirRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.MkdirResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("mkdir"))
              .build();
        }
      }
    }
    return getMkdirMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.FetchLogRequest,
      com.zhss.rpc.model.NameNodeModel.FetchLogResponse> getFetchLogMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "fetchLog",
      requestType = com.zhss.rpc.model.NameNodeModel.FetchLogRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.FetchLogResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.FetchLogRequest,
      com.zhss.rpc.model.NameNodeModel.FetchLogResponse> getFetchLogMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.FetchLogRequest, com.zhss.rpc.model.NameNodeModel.FetchLogResponse> getFetchLogMethod;
    if ((getFetchLogMethod = NameNodeServiceGrpc.getFetchLogMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getFetchLogMethod = NameNodeServiceGrpc.getFetchLogMethod) == null) {
          NameNodeServiceGrpc.getFetchLogMethod = getFetchLogMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.FetchLogRequest, com.zhss.rpc.model.NameNodeModel.FetchLogResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "fetchLog"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.FetchLogRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.FetchLogResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("fetchLog"))
              .build();
        }
      }
    }
    return getFetchLogMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest,
      com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> getUpdateCheckPonterTxidMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "updateCheckPonterTxid",
      requestType = com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest,
      com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> getUpdateCheckPonterTxidMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest, com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> getUpdateCheckPonterTxidMethod;
    if ((getUpdateCheckPonterTxidMethod = NameNodeServiceGrpc.getUpdateCheckPonterTxidMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getUpdateCheckPonterTxidMethod = NameNodeServiceGrpc.getUpdateCheckPonterTxidMethod) == null) {
          NameNodeServiceGrpc.getUpdateCheckPonterTxidMethod = getUpdateCheckPonterTxidMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest, com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "updateCheckPonterTxid"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("updateCheckPonterTxid"))
              .build();
        }
      }
    }
    return getUpdateCheckPonterTxidMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ShutDownRequest,
      com.zhss.rpc.model.NameNodeModel.ShutDownResponse> getShutDownMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "shutDown",
      requestType = com.zhss.rpc.model.NameNodeModel.ShutDownRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.ShutDownResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ShutDownRequest,
      com.zhss.rpc.model.NameNodeModel.ShutDownResponse> getShutDownMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ShutDownRequest, com.zhss.rpc.model.NameNodeModel.ShutDownResponse> getShutDownMethod;
    if ((getShutDownMethod = NameNodeServiceGrpc.getShutDownMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getShutDownMethod = NameNodeServiceGrpc.getShutDownMethod) == null) {
          NameNodeServiceGrpc.getShutDownMethod = getShutDownMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.ShutDownRequest, com.zhss.rpc.model.NameNodeModel.ShutDownResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "shutDown"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ShutDownRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ShutDownResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("shutDown"))
              .build();
        }
      }
    }
    return getShutDownMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.CreateFileRequest,
      com.zhss.rpc.model.NameNodeModel.CreateFileResponse> getCreateFileMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "createFile",
      requestType = com.zhss.rpc.model.NameNodeModel.CreateFileRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.CreateFileResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.CreateFileRequest,
      com.zhss.rpc.model.NameNodeModel.CreateFileResponse> getCreateFileMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.CreateFileRequest, com.zhss.rpc.model.NameNodeModel.CreateFileResponse> getCreateFileMethod;
    if ((getCreateFileMethod = NameNodeServiceGrpc.getCreateFileMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getCreateFileMethod = NameNodeServiceGrpc.getCreateFileMethod) == null) {
          NameNodeServiceGrpc.getCreateFileMethod = getCreateFileMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.CreateFileRequest, com.zhss.rpc.model.NameNodeModel.CreateFileResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "createFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.CreateFileRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.CreateFileResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("createFile"))
              .build();
        }
      }
    }
    return getCreateFileMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> getAllocateDataNodeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "allocateDataNode",
      requestType = com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> getAllocateDataNodeMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest, com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> getAllocateDataNodeMethod;
    if ((getAllocateDataNodeMethod = NameNodeServiceGrpc.getAllocateDataNodeMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getAllocateDataNodeMethod = NameNodeServiceGrpc.getAllocateDataNodeMethod) == null) {
          NameNodeServiceGrpc.getAllocateDataNodeMethod = getAllocateDataNodeMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest, com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "allocateDataNode"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("allocateDataNode"))
              .build();
        }
      }
    }
    return getAllocateDataNodeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest,
      com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> getInformReceivedReplicateMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "informReceivedReplicate",
      requestType = com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest,
      com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> getInformReceivedReplicateMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest, com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> getInformReceivedReplicateMethod;
    if ((getInformReceivedReplicateMethod = NameNodeServiceGrpc.getInformReceivedReplicateMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getInformReceivedReplicateMethod = NameNodeServiceGrpc.getInformReceivedReplicateMethod) == null) {
          NameNodeServiceGrpc.getInformReceivedReplicateMethod = getInformReceivedReplicateMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest, com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "informReceivedReplicate"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("informReceivedReplicate"))
              .build();
        }
      }
    }
    return getInformReceivedReplicateMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest,
      com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> getReportCompleteFileInfoMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ReportCompleteFileInfo",
      requestType = com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest,
      com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> getReportCompleteFileInfoMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest, com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> getReportCompleteFileInfoMethod;
    if ((getReportCompleteFileInfoMethod = NameNodeServiceGrpc.getReportCompleteFileInfoMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getReportCompleteFileInfoMethod = NameNodeServiceGrpc.getReportCompleteFileInfoMethod) == null) {
          NameNodeServiceGrpc.getReportCompleteFileInfoMethod = getReportCompleteFileInfoMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest, com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ReportCompleteFileInfo"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("ReportCompleteFileInfo"))
              .build();
        }
      }
    }
    return getReportCompleteFileInfoMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest,
      com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> getGetDataNodeForFileMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "GetDataNodeForFile",
      requestType = com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest,
      com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> getGetDataNodeForFileMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest, com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> getGetDataNodeForFileMethod;
    if ((getGetDataNodeForFileMethod = NameNodeServiceGrpc.getGetDataNodeForFileMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getGetDataNodeForFileMethod = NameNodeServiceGrpc.getGetDataNodeForFileMethod) == null) {
          NameNodeServiceGrpc.getGetDataNodeForFileMethod = getGetDataNodeForFileMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest, com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetDataNodeForFile"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("GetDataNodeForFile"))
              .build();
        }
      }
    }
    return getGetDataNodeForFileMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> getReallocateDataNodeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ReallocateDataNode",
      requestType = com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> getReallocateDataNodeMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest, com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> getReallocateDataNodeMethod;
    if ((getReallocateDataNodeMethod = NameNodeServiceGrpc.getReallocateDataNodeMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getReallocateDataNodeMethod = NameNodeServiceGrpc.getReallocateDataNodeMethod) == null) {
          NameNodeServiceGrpc.getReallocateDataNodeMethod = getReallocateDataNodeMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest, com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ReallocateDataNode"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("ReallocateDataNode"))
              .build();
        }
      }
    }
    return getReallocateDataNodeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> getChooseOtherDataNodeMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "ChooseOtherDataNode",
      requestType = com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest,
      com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> getChooseOtherDataNodeMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest, com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> getChooseOtherDataNodeMethod;
    if ((getChooseOtherDataNodeMethod = NameNodeServiceGrpc.getChooseOtherDataNodeMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getChooseOtherDataNodeMethod = NameNodeServiceGrpc.getChooseOtherDataNodeMethod) == null) {
          NameNodeServiceGrpc.getChooseOtherDataNodeMethod = getChooseOtherDataNodeMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest, com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ChooseOtherDataNode"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("ChooseOtherDataNode"))
              .build();
        }
      }
    }
    return getChooseOtherDataNodeMethod;
  }

  private static volatile io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RebalanceRequest,
      com.zhss.rpc.model.NameNodeModel.RebalanceResponse> getRebalanceMethod;

  @io.grpc.stub.annotations.RpcMethod(
      fullMethodName = SERVICE_NAME + '/' + "Rebalance",
      requestType = com.zhss.rpc.model.NameNodeModel.RebalanceRequest.class,
      responseType = com.zhss.rpc.model.NameNodeModel.RebalanceResponse.class,
      methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
  public static io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RebalanceRequest,
      com.zhss.rpc.model.NameNodeModel.RebalanceResponse> getRebalanceMethod() {
    io.grpc.MethodDescriptor<com.zhss.rpc.model.NameNodeModel.RebalanceRequest, com.zhss.rpc.model.NameNodeModel.RebalanceResponse> getRebalanceMethod;
    if ((getRebalanceMethod = NameNodeServiceGrpc.getRebalanceMethod) == null) {
      synchronized (NameNodeServiceGrpc.class) {
        if ((getRebalanceMethod = NameNodeServiceGrpc.getRebalanceMethod) == null) {
          NameNodeServiceGrpc.getRebalanceMethod = getRebalanceMethod =
              io.grpc.MethodDescriptor.<com.zhss.rpc.model.NameNodeModel.RebalanceRequest, com.zhss.rpc.model.NameNodeModel.RebalanceResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
              .setFullMethodName(generateFullMethodName(SERVICE_NAME, "Rebalance"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.RebalanceRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.zhss.rpc.model.NameNodeModel.RebalanceResponse.getDefaultInstance()))
              .setSchemaDescriptor(new NameNodeServiceMethodDescriptorSupplier("Rebalance"))
              .build();
        }
      }
    }
    return getRebalanceMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static NameNodeServiceStub newStub(io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceStub>() {
        @Override
        public NameNodeServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new NameNodeServiceStub(channel, callOptions);
        }
      };
    return NameNodeServiceStub.newStub(factory, channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static NameNodeServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceBlockingStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceBlockingStub>() {
        @Override
        public NameNodeServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new NameNodeServiceBlockingStub(channel, callOptions);
        }
      };
    return NameNodeServiceBlockingStub.newStub(factory, channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static NameNodeServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceFutureStub> factory =
      new io.grpc.stub.AbstractStub.StubFactory<NameNodeServiceFutureStub>() {
        @Override
        public NameNodeServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
          return new NameNodeServiceFutureStub(channel, callOptions);
        }
      };
    return NameNodeServiceFutureStub.newStub(factory, channel);
  }

  /**
   */
  public interface AsyncService {

    /**
     */
    default void register(com.zhss.rpc.model.NameNodeModel.RegisterRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RegisterResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRegisterMethod(), responseObserver);
    }

    /**
     */
    default void heartbeat(com.zhss.rpc.model.NameNodeModel.HeartbeatRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getHeartbeatMethod(), responseObserver);
    }

    /**
     */
    default void mkdir(com.zhss.rpc.model.NameNodeModel.MkdirRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.MkdirResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getMkdirMethod(), responseObserver);
    }

    /**
     */
    default void fetchLog(com.zhss.rpc.model.NameNodeModel.FetchLogRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.FetchLogResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchLogMethod(), responseObserver);
    }

    /**
     */
    default void updateCheckPonterTxid(com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateCheckPonterTxidMethod(), responseObserver);
    }

    /**
     */
    default void shutDown(com.zhss.rpc.model.NameNodeModel.ShutDownRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ShutDownResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getShutDownMethod(), responseObserver);
    }

    /**
     */
    default void createFile(com.zhss.rpc.model.NameNodeModel.CreateFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.CreateFileResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateFileMethod(), responseObserver);
    }

    /**
     */
    default void allocateDataNode(com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAllocateDataNodeMethod(), responseObserver);
    }

    /**
     */
    default void informReceivedReplicate(com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getInformReceivedReplicateMethod(), responseObserver);
    }

    /**
     */
    default void reportCompleteFileInfo(com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReportCompleteFileInfoMethod(), responseObserver);
    }

    /**
     */
    default void getDataNodeForFile(com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetDataNodeForFileMethod(), responseObserver);
    }

    /**
     */
    default void reallocateDataNode(com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getReallocateDataNodeMethod(), responseObserver);
    }

    /**
     */
    default void chooseOtherDataNode(com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getChooseOtherDataNodeMethod(), responseObserver);
    }

    /**
     */
    default void rebalance(com.zhss.rpc.model.NameNodeModel.RebalanceRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RebalanceResponse> responseObserver) {
      io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRebalanceMethod(), responseObserver);
    }
  }

  /**
   * Base class for the server implementation of the service NameNodeService.
   */
  public static abstract class NameNodeServiceImplBase
      implements io.grpc.BindableService, AsyncService {

    @Override public final io.grpc.ServerServiceDefinition bindService() {
      return NameNodeServiceGrpc.bindService(this);
    }
  }

  /**
   * A stub to allow clients to do asynchronous rpc calls to service NameNodeService.
   */
  public static final class NameNodeServiceStub
      extends io.grpc.stub.AbstractAsyncStub<NameNodeServiceStub> {
    private NameNodeServiceStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected NameNodeServiceStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new NameNodeServiceStub(channel, callOptions);
    }

    /**
     */
    public void register(com.zhss.rpc.model.NameNodeModel.RegisterRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RegisterResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRegisterMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void heartbeat(com.zhss.rpc.model.NameNodeModel.HeartbeatRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getHeartbeatMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void mkdir(com.zhss.rpc.model.NameNodeModel.MkdirRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.MkdirResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getMkdirMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void fetchLog(com.zhss.rpc.model.NameNodeModel.FetchLogRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.FetchLogResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getFetchLogMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void updateCheckPonterTxid(com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getUpdateCheckPonterTxidMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void shutDown(com.zhss.rpc.model.NameNodeModel.ShutDownRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ShutDownResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getShutDownMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void createFile(com.zhss.rpc.model.NameNodeModel.CreateFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.CreateFileResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getCreateFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void allocateDataNode(com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getAllocateDataNodeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void informReceivedReplicate(com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getInformReceivedReplicateMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void reportCompleteFileInfo(com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getReportCompleteFileInfoMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void getDataNodeForFile(com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getGetDataNodeForFileMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void reallocateDataNode(com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getReallocateDataNodeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void chooseOtherDataNode(com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getChooseOtherDataNodeMethod(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void rebalance(com.zhss.rpc.model.NameNodeModel.RebalanceRequest request,
        io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RebalanceResponse> responseObserver) {
      io.grpc.stub.ClientCalls.asyncUnaryCall(
          getChannel().newCall(getRebalanceMethod(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * A stub to allow clients to do synchronous rpc calls to service NameNodeService.
   */
  public static final class NameNodeServiceBlockingStub
      extends io.grpc.stub.AbstractBlockingStub<NameNodeServiceBlockingStub> {
    private NameNodeServiceBlockingStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected NameNodeServiceBlockingStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new NameNodeServiceBlockingStub(channel, callOptions);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.RegisterResponse register(com.zhss.rpc.model.NameNodeModel.RegisterRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRegisterMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.HeartbeatResponse heartbeat(com.zhss.rpc.model.NameNodeModel.HeartbeatRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getHeartbeatMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.MkdirResponse mkdir(com.zhss.rpc.model.NameNodeModel.MkdirRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getMkdirMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.FetchLogResponse fetchLog(com.zhss.rpc.model.NameNodeModel.FetchLogRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getFetchLogMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse updateCheckPonterTxid(com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getUpdateCheckPonterTxidMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.ShutDownResponse shutDown(com.zhss.rpc.model.NameNodeModel.ShutDownRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getShutDownMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.CreateFileResponse createFile(com.zhss.rpc.model.NameNodeModel.CreateFileRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getCreateFileMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse allocateDataNode(com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getAllocateDataNodeMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse informReceivedReplicate(com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getInformReceivedReplicateMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse reportCompleteFileInfo(com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getReportCompleteFileInfoMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse getDataNodeForFile(com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getGetDataNodeForFileMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse reallocateDataNode(com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getReallocateDataNodeMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse chooseOtherDataNode(com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getChooseOtherDataNodeMethod(), getCallOptions(), request);
    }

    /**
     */
    public com.zhss.rpc.model.NameNodeModel.RebalanceResponse rebalance(com.zhss.rpc.model.NameNodeModel.RebalanceRequest request) {
      return io.grpc.stub.ClientCalls.blockingUnaryCall(
          getChannel(), getRebalanceMethod(), getCallOptions(), request);
    }
  }

  /**
   * A stub to allow clients to do ListenableFuture-style rpc calls to service NameNodeService.
   */
  public static final class NameNodeServiceFutureStub
      extends io.grpc.stub.AbstractFutureStub<NameNodeServiceFutureStub> {
    private NameNodeServiceFutureStub(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @Override
    protected NameNodeServiceFutureStub build(
        io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
      return new NameNodeServiceFutureStub(channel, callOptions);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.RegisterResponse> register(
        com.zhss.rpc.model.NameNodeModel.RegisterRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRegisterMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.HeartbeatResponse> heartbeat(
        com.zhss.rpc.model.NameNodeModel.HeartbeatRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getHeartbeatMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.MkdirResponse> mkdir(
        com.zhss.rpc.model.NameNodeModel.MkdirRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getMkdirMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.FetchLogResponse> fetchLog(
        com.zhss.rpc.model.NameNodeModel.FetchLogRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getFetchLogMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse> updateCheckPonterTxid(
        com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getUpdateCheckPonterTxidMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.ShutDownResponse> shutDown(
        com.zhss.rpc.model.NameNodeModel.ShutDownRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getShutDownMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.CreateFileResponse> createFile(
        com.zhss.rpc.model.NameNodeModel.CreateFileRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getCreateFileMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse> allocateDataNode(
        com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getAllocateDataNodeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse> informReceivedReplicate(
        com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getInformReceivedReplicateMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse> reportCompleteFileInfo(
        com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getReportCompleteFileInfoMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse> getDataNodeForFile(
        com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getGetDataNodeForFileMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse> reallocateDataNode(
        com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getReallocateDataNodeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse> chooseOtherDataNode(
        com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getChooseOtherDataNodeMethod(), getCallOptions()), request);
    }

    /**
     */
    public com.google.common.util.concurrent.ListenableFuture<com.zhss.rpc.model.NameNodeModel.RebalanceResponse> rebalance(
        com.zhss.rpc.model.NameNodeModel.RebalanceRequest request) {
      return io.grpc.stub.ClientCalls.futureUnaryCall(
          getChannel().newCall(getRebalanceMethod(), getCallOptions()), request);
    }
  }

  private static final int METHODID_REGISTER = 0;
  private static final int METHODID_HEARTBEAT = 1;
  private static final int METHODID_MKDIR = 2;
  private static final int METHODID_FETCH_LOG = 3;
  private static final int METHODID_UPDATE_CHECK_PONTER_TXID = 4;
  private static final int METHODID_SHUT_DOWN = 5;
  private static final int METHODID_CREATE_FILE = 6;
  private static final int METHODID_ALLOCATE_DATA_NODE = 7;
  private static final int METHODID_INFORM_RECEIVED_REPLICATE = 8;
  private static final int METHODID_REPORT_COMPLETE_FILE_INFO = 9;
  private static final int METHODID_GET_DATA_NODE_FOR_FILE = 10;
  private static final int METHODID_REALLOCATE_DATA_NODE = 11;
  private static final int METHODID_CHOOSE_OTHER_DATA_NODE = 12;
  private static final int METHODID_REBALANCE = 13;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final AsyncService serviceImpl;
    private final int methodId;

    MethodHandlers(AsyncService serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @Override
    @SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_REGISTER:
          serviceImpl.register((com.zhss.rpc.model.NameNodeModel.RegisterRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RegisterResponse>) responseObserver);
          break;
        case METHODID_HEARTBEAT:
          serviceImpl.heartbeat((com.zhss.rpc.model.NameNodeModel.HeartbeatRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.HeartbeatResponse>) responseObserver);
          break;
        case METHODID_MKDIR:
          serviceImpl.mkdir((com.zhss.rpc.model.NameNodeModel.MkdirRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.MkdirResponse>) responseObserver);
          break;
        case METHODID_FETCH_LOG:
          serviceImpl.fetchLog((com.zhss.rpc.model.NameNodeModel.FetchLogRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.FetchLogResponse>) responseObserver);
          break;
        case METHODID_UPDATE_CHECK_PONTER_TXID:
          serviceImpl.updateCheckPonterTxid((com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse>) responseObserver);
          break;
        case METHODID_SHUT_DOWN:
          serviceImpl.shutDown((com.zhss.rpc.model.NameNodeModel.ShutDownRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ShutDownResponse>) responseObserver);
          break;
        case METHODID_CREATE_FILE:
          serviceImpl.createFile((com.zhss.rpc.model.NameNodeModel.CreateFileRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.CreateFileResponse>) responseObserver);
          break;
        case METHODID_ALLOCATE_DATA_NODE:
          serviceImpl.allocateDataNode((com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse>) responseObserver);
          break;
        case METHODID_INFORM_RECEIVED_REPLICATE:
          serviceImpl.informReceivedReplicate((com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse>) responseObserver);
          break;
        case METHODID_REPORT_COMPLETE_FILE_INFO:
          serviceImpl.reportCompleteFileInfo((com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse>) responseObserver);
          break;
        case METHODID_GET_DATA_NODE_FOR_FILE:
          serviceImpl.getDataNodeForFile((com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse>) responseObserver);
          break;
        case METHODID_REALLOCATE_DATA_NODE:
          serviceImpl.reallocateDataNode((com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse>) responseObserver);
          break;
        case METHODID_CHOOSE_OTHER_DATA_NODE:
          serviceImpl.chooseOtherDataNode((com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse>) responseObserver);
          break;
        case METHODID_REBALANCE:
          serviceImpl.rebalance((com.zhss.rpc.model.NameNodeModel.RebalanceRequest) request,
              (io.grpc.stub.StreamObserver<com.zhss.rpc.model.NameNodeModel.RebalanceResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @Override
    @SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
    return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
        .addMethod(
          getRegisterMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.RegisterRequest,
              com.zhss.rpc.model.NameNodeModel.RegisterResponse>(
                service, METHODID_REGISTER)))
        .addMethod(
          getHeartbeatMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.HeartbeatRequest,
              com.zhss.rpc.model.NameNodeModel.HeartbeatResponse>(
                service, METHODID_HEARTBEAT)))
        .addMethod(
          getMkdirMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.MkdirRequest,
              com.zhss.rpc.model.NameNodeModel.MkdirResponse>(
                service, METHODID_MKDIR)))
        .addMethod(
          getFetchLogMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.FetchLogRequest,
              com.zhss.rpc.model.NameNodeModel.FetchLogResponse>(
                service, METHODID_FETCH_LOG)))
        .addMethod(
          getUpdateCheckPonterTxidMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.UpdateTxidRequest,
              com.zhss.rpc.model.NameNodeModel.UpdateTxidResponse>(
                service, METHODID_UPDATE_CHECK_PONTER_TXID)))
        .addMethod(
          getShutDownMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.ShutDownRequest,
              com.zhss.rpc.model.NameNodeModel.ShutDownResponse>(
                service, METHODID_SHUT_DOWN)))
        .addMethod(
          getCreateFileMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.CreateFileRequest,
              com.zhss.rpc.model.NameNodeModel.CreateFileResponse>(
                service, METHODID_CREATE_FILE)))
        .addMethod(
          getAllocateDataNodeMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.AllocateDataNodeRequest,
              com.zhss.rpc.model.NameNodeModel.AllocateDataNodeResponse>(
                service, METHODID_ALLOCATE_DATA_NODE)))
        .addMethod(
          getInformReceivedReplicateMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateRequest,
              com.zhss.rpc.model.NameNodeModel.InformReceivedReplicateResponse>(
                service, METHODID_INFORM_RECEIVED_REPLICATE)))
        .addMethod(
          getReportCompleteFileInfoMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.ReportCompleteFileRequest,
              com.zhss.rpc.model.NameNodeModel.ReportCompleteFileResponse>(
                service, METHODID_REPORT_COMPLETE_FILE_INFO)))
        .addMethod(
          getGetDataNodeForFileMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.GetDataForFileRequest,
              com.zhss.rpc.model.NameNodeModel.GetDataForFileResponse>(
                service, METHODID_GET_DATA_NODE_FOR_FILE)))
        .addMethod(
          getReallocateDataNodeMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeRequest,
              com.zhss.rpc.model.NameNodeModel.ReallocateDataNodeResponse>(
                service, METHODID_REALLOCATE_DATA_NODE)))
        .addMethod(
          getChooseOtherDataNodeMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeRequest,
              com.zhss.rpc.model.NameNodeModel.ChooseOtherDataNodeResponse>(
                service, METHODID_CHOOSE_OTHER_DATA_NODE)))
        .addMethod(
          getRebalanceMethod(),
          io.grpc.stub.ServerCalls.asyncUnaryCall(
            new MethodHandlers<
              com.zhss.rpc.model.NameNodeModel.RebalanceRequest,
              com.zhss.rpc.model.NameNodeModel.RebalanceResponse>(
                service, METHODID_REBALANCE)))
        .build();
  }

  private static abstract class NameNodeServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    NameNodeServiceBaseDescriptorSupplier() {}

    @Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return NameNodeRpc.getDescriptor();
    }

    @Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("NameNodeService");
    }
  }

  private static final class NameNodeServiceFileDescriptorSupplier
      extends NameNodeServiceBaseDescriptorSupplier {
    NameNodeServiceFileDescriptorSupplier() {}
  }

  private static final class NameNodeServiceMethodDescriptorSupplier
      extends NameNodeServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    NameNodeServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (NameNodeServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new NameNodeServiceFileDescriptorSupplier())
              .addMethod(getRegisterMethod())
              .addMethod(getHeartbeatMethod())
              .addMethod(getMkdirMethod())
              .addMethod(getFetchLogMethod())
              .addMethod(getUpdateCheckPonterTxidMethod())
              .addMethod(getShutDownMethod())
              .addMethod(getCreateFileMethod())
              .addMethod(getAllocateDataNodeMethod())
              .addMethod(getInformReceivedReplicateMethod())
              .addMethod(getReportCompleteFileInfoMethod())
              .addMethod(getGetDataNodeForFileMethod())
              .addMethod(getReallocateDataNodeMethod())
              .addMethod(getChooseOtherDataNodeMethod())
              .addMethod(getRebalanceMethod())
              .build();
        }
      }
    }
    return result;
  }
}
